Ext.onReady(function() {
	if (username == null)
		return;
	Ext.QuickTips.init();

	function pageLoad() {
		Ext.define('RuleModel', {
			extend : 'Ext.data.Model',
			fields : [{
				name : 'rulId'
			}, {
				name : 'rulName'
			}, {
				name : 'rulDescription'
			}, {
				name : 'rulEnabled',
				convert : function(value, record) {
					if (value == 1)
						return "是";
					if (value == 0)
						return "否";
				}
			}, {
				name : 'rulSeverity',
				convert : function(value, record) {
					if (value == 1)
						return "一般";
					if (value == 0)
						return "轻微";
					if (value == 2)
						return "严重";
				}
			}, {
				name : 'rulCategory',
				type : 'date',
				convert : function(value, record) {
					if (value == 0)
						return "文件系统";
					if (value == 1)
						return "数据库";
					if (value == 2)
						return "安全";
					if (value == 3)
						return "云平台服务";
					if (value == 4)
						return "其他";
				}
			}, {
				name : 'rulFirstAlerts'
			}, {
				name : 'rulFirstDaysEach'
			}, {
				name : 'rulNextAlerts'
			}, {
				name : 'rulNextDaysEach'
			}, {
				name : 'rulAllFurtherDayEach'
			}]
		});

		Ext.define('RuleSetModel', {
			extend : 'Ext.data.Model',
			fields : [{
				name : 'rusId'
			}, {
				name : 'rusName'
			}, {
				name : 'rusDescription'
			}, {
				name : 'rusVersion'
			}, {
				name : 'rusReleaseStatus'
			}, {
				name : 'rusPublic',
				convert : function(value, record) {
					if (value == 1)
						return "Private";
					if (value == 0)
						return "Public";
					if (value == 2)
						return "Protected";
				}
			}, {
				name : 'rusCreateTime'
			}]
		});

		var ruleStore = Ext.create('Ext.data.Store', {
			autoload : true,
			pageSize : pSize,
			model : 'RuleModel',
			remoteSort : true,
			proxy : {
				type : 'ajax',
				url : 'ruleset_getRules.action',
				method : 'POST',
				reader : {
					idProperty : 'rulId',
					root : 'result.list',
					totalProperty : 'total'
				},
				simpleSortMode : true
			}
		});
		var RuleSetStore = Ext.create('Ext.data.Store', {
			autoload : true,
			pageSize : pSize,
			model : 'RuleSetModel',
			remoteSort : true,
			proxy : {
				type : 'ajax',
				url : 'ruleset_ruleSetList.action',
				method : 'POST',
				reader : {
					idProperty : 'rusId',
					root : 'result.list',
					totalProperty : 'total'
				},
				simpleSortMode : true
			}
		});

		var RuleSetGrid = Ext.create('Ext.grid.Panel', {
			itemId : 'RuleSetGrid',
			store : RuleSetStore,

			columnLines : true,
			autoHeight : true,
			autoWidth : true,
			title : '规则集列表',
			frame : true,
			loadMask : true,

			viewConfig : {
				stripeRows : true
			},
			columns : [{
				text : "规则集名称",
				width : 200,
				dataIndex : 'rusName',
				sortable : true
			}, {
				text : "规则集Id",
				width : 100,
				dataIndex : 'rusId',
				sortable : true,
				hidden : true
			}, {
				text : "规则集描述",
				width : 350,
				dataIndex : 'rusDescription'
			},
			//, sortable:true,renderer: function (value, meta, record) {return record.raw.application.appName;}},
			{
				text : "规则集版本",
				width : 100,
				dataIndex : 'rusVersion',
				sortable : true
			}, {
				text : "规则集创建时间",
				width : 200,
				dataIndex : 'rusCreateTime',
				sortable : true
			}, {
				text : "规则集公共性",
				width : 200,
				dataIndex : 'rusPublic',
				sortable : true
			}, {
				text:"操作",
				menuDisabled : true,
				sortable : false,
				xtype : 'actioncolumn',
				items : [{
					iconCls : 'icon-delete', // Use a URL in the icon config
					tooltip : '删除规则集',
					text : '删除',
					handler : function(grid, rowIndex, colIndex) {

						Ext.MessageBox.confirm('提示', '您确定要删除所选吗?', function(btnId) {
							if (btnId == 'yes') {

								var rec = grid.store.getAt(rowIndex);
								var msgTip = Ext.MessageBox.show({
									title : '提示',
									width : 250,
									msg : '正在删除请稍候...'
								});
								Ext.Ajax.request({
									url : 'ruleset_delRuleSet.action',
									params : {
										rusName : rec.get('rusName'),
										rusId : rec.get('rusId')
									},
									method : 'POST',
									success : function(response) {
										msgTip.hide();
										var result = Ext.JSON.decode(response.responseText);
										if (result.success) {
											grid.store.remove(rec);
											Ext.Msg.alert('提示', '规则集删除成功!');
										} else {
											Ext.Msg.alert('提示', '规则集删除失败!信息被其他数据引用');
										}
									},
									failure : function(response) {

										Ext.Msg.alert('提示', '规则集删除失败!信息被其他数据引用');

									}
								});
							}
						});
					}
				}, {
					iconCls : 'icon-editfind', // Use a URL in the icon config
					tooltip : '查看规则集',
					attr : 'style="margin-left:100"',
					handler : function(grid, rowIndex, colIndex) {
						var rec = grid.store.getAt(rowIndex);
						showWindow(rec);
					}
				}, {
					iconCls : 'icon-downArrow', // Use a URL in the icon config
					tooltip : '下载规则集',
					attr : 'style="margin-left:100"',
					handler : function(grid, rowIndex, colIndex) {
						var rec = grid.store.getAt(rowIndex);
						showWindow(rec);
					}
				}, {
					iconCls : 'icon-edit', // Use a URL in the icon config
					tooltip : '选择规则',
					text : '选择规则',
					handler : function(grid, rowIndex, colIndex) {
						var rec = grid.store.getAt(rowIndex);

						var ruleGrid = Ext.create('Ext.grid.GridPanel', {
							height : 400,
							width : 800,
							store : ruleStore,
							selType : 'checkboxmodel',
							multiSelect : true,
							selModel : 'single',
							columns : [{
								header : "规则名",
								dataIndex : 'rulName',
								width : 100
							}, {
								header : "规则描述",
								dataIndex : 'rulDescription',
								width : 330,
								sortable : true
							}, {
								header : "规则严重性",
								dataIndex : 'rulSeverity',
								width : 110,
								sortable : true
							}, {
								header : "规则类别",
								dataIndex : 'rulCategory',
								width : 110
							}, {
								header : "规则可用性",
								dataIndex : 'rulEnabled',
								width : 90
							}],
							bbar : {
								items : [{
									pressed : true,
									enableToggle : true,
									text : '确定',
									cls : 'x-btn-text-icon details',
									handler : function() {
										var datas = ruleGrid.getSelectionModel().getSelection();
										var i;
										var s = "{";
										for ( i = 0; i < datas.length; ++i) {
											if (i == 0) {
												s += '\"' + i + '\":\"' + datas[i].get("rulId") + "\"";
											} else {
												s += ',\"' + i + '\":\"' + datas[i].get("rulId") + "\"";
											}

										}
										s += "}";
										Ext.Ajax.request({
											url : 'ruleset_conRules.action',
											params : {
												rusId : rec.get('rusId'),
												datas : s
											},
											method : 'POST',
											success : function(response) {
												var result = Ext.JSON.decode(response.responseText);
												if (result.success) {
													Ext.Msg.alert('提示', '添加规则成功!');
													ruleWin.destroy();
												} else {
													Ext.Msg.alert('提示', '添加规则失败!');
												}
											},
											failure : function(response) {

												Ext.Msg.alert('提示', '添加规则失败!');

											}
										});
									}
								}]
							}

						});
						Ext.Ajax.request({
							url : 'ruleset_showSelectedRules.action',
							params : {
								rusId : rec.get('rusId'),
							},
							method : 'POST',
							success : function(response) {
								var result = Ext.JSON.decode(response.responseText);
								//ruleGrid.getSelectionModel().select(1, true, false);
								var strs = result.selectedRules.split(",");
								//字符分割
								var selMod = ruleGrid.getSelectionModel();
								for (var i = 0; i < strs.length; i++) {
									selMod.select(parseInt(strs[i]), true, false);
								}
							},
							failure : function(response) {

								Ext.Msg.alert('提示', '添加规则失败!');

							}
						});
						ruleStore.load();
						var ruleWin = new Ext.Window({// 创建弹出窗口
							layout : 'fit',
							width : 800,
							closeAction : 'hide',
							height : 400,
							resizable : false,
							shadow : true,
							modal : true,
							closable : true,
							bodyStyle : 'padding:5 5 5 5',
							animCollapse : true,
							items : [ruleGrid]
						});
						ruleWin.show();

					}
				}]
			}], // end columns
			features : [{
				ftype : 'filters',
				encode : true,
				local : false,
				filters : [{
					type : 'string',
					dataIndex : 'repName',
					disabled : false
				}, {
					type : 'string',
					dataIndex : 'rusDescription',
					disabled : false
				}, {
					type : 'string',
					dataIndex : 'rusVersion',
					disabled : false
				}]
			}],
			dockedItems : [{
				dock : 'top',
				xtype : 'toolbar',
				items : [{
					itemId : 'addButton',
					text : '创建规则集',
					tooltip : '创建规则集',
					iconCls : 'icon-add',
					scope : this,
					handler : function() {
						var rec = null;
						showWindow(rec);
					}
				}, '-', {
					xtype : 'FileDownloader',
					itemId : 'RuleSetDownloader',
					width : 0,
					height : 0
				}, '-', {
					text : 'Excel',
					tooltip : '导出Excel列表',
					scope : this,
					iconCls : 'icon-excel',
					handler : function() {
						//                    var list = getExcelParams(Ext.getCmp('UsersGrid'));
						var list = getExcelParams(Ext.getCmp('RuleSetGrid'));
						var downloader = Ext.getCmp('RuleSetDownloader');
						downloader.load({
							params : {
								preFilter : list[0],
								filter : list[1],
								sort : list[2],
								dir : list[3],
								headers : list[4],
								cheaders : list[5],
								title : list[6]
							},
							url : 'userstoExcel.action'
						});
					}
				}, '-', '显示记录数', {
					itemId : 'RuleSetCmbNum',
					name : 'RuleSetCmbNum',
					xtype : 'combo',
					width : 50,
					allowBlank : false,
					blankText : '必须选择页面大小!',
					store : pageStore,
					value : pSize,
					editable : false,
					loadingText : '正在加载...',
					displayField : 'name',
					valueField : 'abbr',
					emptyText : '请选择页面大小',
					queryMode : 'local',
					listeners : {
						select : function(combo, record, index) {
							pSize = this.getValue();
							RuleSetStore.pageSize = pSize;
							RuleSetStore.load();
						}
					}
				}]
			}, Ext.create('Ext.PagingToolbar', {
				pageSize : pSize,
				dock : 'bottom',
				store : RuleSetStore,
				displayInfo : true,
				displayMsg : '显示 {0} - {1} 条，共计 {2} 条',
				emptyMsg : '没有数据',
				plugins : Ext.create('Ext.ux.ProgressBarPager', {})
			})], // end docked items
			listeners : {
				beforerender : function(grid, opts) {
					RuleSetStore.pageSize = 15;
					RuleSetStore.load();
				}
			}

		});
		//end ReportGrid

		// 查看规则集窗口
		function showWindow(rec) {
			console.log("showWindow-RuleSet");
			console.log(rec);
			var ruleSetForm = Ext.create('Ext.form.Panel', {
				frame : true,
				bodyStyle : 'padding:5px 5px 0',
				autoWidth : true,
				fieldDefaults : {
					msgTarget : 'side',
					labelWidth : 120
				},
				defaultType : 'textfield',
				defaults : {
					anchor : '100%'
				},
				items : [{
					xtype : 'textfield',
					itemId : 'id',
					name : 'id',
					columnWidth : 0.5,
					hidden : true
				}, {
					xtype : 'textfield',
					itemId : 'rusName',
					name : 'rusName',
					columnWidth : 0.5,
					fieldLabel : '规则集名<span style="color:red;">*</span>',
					allowBlank : false

				}, {
					xtype : 'textfield',
					itemId : 'rusDescription',
					name : 'rusDescription',
					columnWidth : 0.5,
					fieldLabel : '规则集描述<span style="color:red;">*</span>',
					allowBlank : false

				}, {
					xtype : 'numberfield',
					itemId : 'rusVersion',
					name : 'rusVersion',
					columnWidth : 0.5,
					fieldLabel : '规则集版本<span style="color:red;">*</span>',
					allowBlank : false

				}, {
					xtype : 'combo',
					itemId : 'rusPublic',
					name : 'rusPublic',
					hiddenName : 'name',
					columnWidth : 0.5,
					fieldLabel : '规则集公共性<span style="color:red;">*</span>',
					allowBlank : false,
					multiSelect : false,
					valueField : 'value',
					displayField : 'name',
					store : new Ext.data.SimpleStore({
						fields : ['name', 'value'],
						data : [['Public', '0'], ['Private', '1'], ['Protected', '2']]
					}),
					mode : 'local', // default: remote
					emptyText : '请选择公共性',
					readOnly : false,
					editable : false,

				}],
				buttons : [{
					text : '确定',
					handler : submitForm
				}, {
					text : '取消',
					handler : function() {
						ruleSetForm.destroy();
						ruleSetWindow.destroy();
					}
				}]

			});
			function submitForm() {
				values = ruleSetForm.form.getValues();
				if (values.id == "") {
					values.id = 0;
				}
				var JSONobj = [];
				//JSONobj.push(values);
				JSONobj.push(JSON.stringify(values));

				ruleSetForm.form.submit({
					clientValidation : true,
					waitMsg : '正在提交数据请稍候...',
					waitTitle : '提示',
					url : 'ruleset_addRuleSet.action',
					method : 'post',
					params : {
						datas : JSONobj
					},
					success : function(form, action) {

						Ext.Msg.alert('提示', "规则集保存成功！");
						RuleSetStore.load();

					},
					failure : function(form, action) {

						Ext.MessageBox.show({
							title : '错误',
							msg : '信息保存失败!请检查规则集是否有重名！',
							buttons : Ext.MessageBox.OK,
							icon : Ext.MessageBox.ERROR
						});

					}
				});
			}

			var ruleSetWindow = new Ext.Window({// 创建弹出窗口
				layout : 'fit',
				width : 450,
				closeAction : 'hide',
				height : 300,
				resizable : false,
				shadow : true,
				modal : true,
				closable : true,
				bodyStyle : 'padding:5 5 5 5',
				animCollapse : true,
				items : [ruleSetForm]
			});
			if (rec != null) {
				ruleSetForm.loadRecord(rec);
				//            ruleSetForm.down('#username').readonly = true;
				//            ruleSetForm.down('#rolecode').setValue(rec.data.webRole.rolecode);
			}
			ruleSetWindow.doLayout();
			ruleSetWindow.show();
		}

		var tab = Ext.getCmp('mainContent').getActiveTab();
		tab.items.add(RuleSetGrid);
		tab.doLayout();
	}

	pageLoad();

}); 